package org.quartz.impl.jdbcjobstore;

import java.sql.Connection;
import java.util.HashSet;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SimpleSemaphore implements Semaphore {

	ThreadLocal lockOwners = new ThreadLocal();

	HashSet locks = new HashSet();

	private final Logger log = LoggerFactory.getLogger(getClass());

	protected Logger getLog() {
		return log;
	}

	private HashSet getThreadLocks() {
		HashSet threadLocks = (HashSet) lockOwners.get();
		if (threadLocks == null) {
			threadLocks = new HashSet();
			lockOwners.set(threadLocks);
		}
		return threadLocks;
	}

	public synchronized boolean obtainLock(Connection conn, String lockName) {
		lockName = lockName.intern();
		Logger log = getLog();

		if (log.isDebugEnabled()) {
			log.debug("Lock '" + lockName + "' is desired by: " + Thread.currentThread().getName());
		}

		if (!isLockOwner(conn, lockName)) {
			if (log.isDebugEnabled()) {
				log.debug("Lock '" + lockName + "' is being obtained: " + Thread.currentThread().getName());
			}
			while (locks.contains(lockName)) {//
				try {
					this.wait();
				} catch (InterruptedException ie) {
					if (log.isDebugEnabled()) {
						log.debug("Lock '" + lockName + "' was not obtained by: " + Thread.currentThread().getName());
					}
				}
			}

			if (log.isDebugEnabled()) {
				log.debug("Lock '" + lockName + "' given to: " + Thread.currentThread().getName());
			}
			getThreadLocks().add(lockName);
			locks.add(lockName);
		} else if (log.isDebugEnabled()) {
			log.debug("Lock '" + lockName + "' already owned by: " + Thread.currentThread().getName()
					+ " -- but not owner!", new Exception("stack-trace of wrongful returner"));
		}

		return true;
	}

	public synchronized void releaseLock(Connection conn, String lockName) {
		lockName = lockName.intern();

		if (isLockOwner(conn, lockName)) {
			if (getLog().isDebugEnabled()) {
				getLog().debug("Lock '" + lockName + "' retuned by: " + Thread.currentThread().getName());
			}
			getThreadLocks().remove(lockName);
			locks.remove(lockName);
			this.notifyAll();
		} else if (getLog().isDebugEnabled()) {
			getLog().debug("Lock '" + lockName + "' attempt to retun by: " + Thread.currentThread().getName()
					+ " -- but not owner!", new Exception("stack-trace of wrongful returner"));
		}
	}

	public synchronized boolean isLockOwner(Connection conn, String lockName) {
		lockName = lockName.intern();

		return getThreadLocks().contains(lockName);
	}

	public boolean requiresConnection() {
		return false;
	}
}
